/*
    Copyright (c) 2001-2003 Swedish Institute of Computer Science.
    All rights reserved.

    Redistribution and use in source and binary forms, with or without modification,
    are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
    3. The name of the author may not be used to endorse or promote products
      derived from this software without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
    WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
    SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
    OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
    OF SUCH DAMAGE.

    This file is part of the lwIP TCP/IP stack.

    Author: Simon Goldschmidt

*/
#ifndef __LWIPOPTS_H__
#define __LWIPOPTS_H__

#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/fcntl.h>
//#include <sys/ioctl.h>
#include <sys/types.h>
//#include <sys/select.h>
#include "sdkconfig.h"

//#include "netif/dhcp_state.h"

/* Enable all Espressif-only options */

/*
    -----------------------------------------------
    ---------- Platform specific locking ----------
    -----------------------------------------------
*/
/**
    SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain
    critical regions during buffer allocation, deallocation and memory
    allocation and deallocation.
*/
#define SYS_LIGHTWEIGHT_PROT        1

/**
    MEMCPY: override this if you have a faster implementation at hand than the
    one included in your C library
*/
#define MEMCPY(dst,src,len)             memcpy(dst,src,len)

/**
    SMEMCPY: override this with care! Some compilers (e.g. gcc) can inline a
    call to memcpy() if the length is known at compile time and is small.
*/
#define SMEMCPY(dst,src,len)            memcpy(dst,src,len)

#define LWIP_RAND       esp_random

/*
    ------------------------------------
    ---------- Memory options ----------
    ------------------------------------
*/
/**
    MEM_LIBC_MALLOC==1: Use malloc/free/realloc provided by your C-library
    instead of the lwip internal allocator. Can save code size if you
    already use it.
*/
#define MEM_LIBC_MALLOC        1

/**
    MEMP_MEM_MALLOC==1: Use mem_malloc/mem_free instead of the lwip pool allocator.
    Especially useful with MEM_LIBC_MALLOC but handle with care regarding execution
    speed and usage from interrupts!
*/
#define MEMP_MEM_MALLOC                 1

/**
    MEM_ALIGNMENT: should be set to the alignment of the CPU
      4 byte alignment -> #define MEM_ALIGNMENT 4
      2 byte alignment -> #define MEM_ALIGNMENT 2
*/
#define MEM_ALIGNMENT           4

/*
    ------------------------------------------------
    ---------- Internal Memory Pool Sizes ----------
    ------------------------------------------------
*/

/**
    MEMP_NUM_NETCONN: the number of struct netconns.
    (only needed if you use the sequential API, like api_lib.c)
*/
#define MEMP_NUM_NETCONN                CONFIG_LWIP_MAX_SOCKETS

/**
    MEMP_NUM_RAW_PCB: Number of raw connection PCBs
    (requires the LWIP_RAW option)
*/
#define MEMP_NUM_RAW_PCB                CONFIG_LWIP_MAX_RAW_PCBS

/**
    MEMP_NUM_TCP_PCB: the number of simultaneously active TCP connections.
    (requires the LWIP_TCP option)
*/
#define MEMP_NUM_TCP_PCB                CONFIG_LWIP_MAX_ACTIVE_TCP

/**
    MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections.
    (requires the LWIP_TCP option)
*/
#define MEMP_NUM_TCP_PCB_LISTEN         CONFIG_LWIP_MAX_LISTENING_TCP

/**
    MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One
    per active UDP "connection".
    (requires the LWIP_UDP option)
*/
#define MEMP_NUM_UDP_PCB                CONFIG_LWIP_MAX_UDP_PCBS

/*
    --------------------------------
    ---------- ARP options -------
    --------------------------------
*/
/**
    ARP_QUEUEING==1: Multiple outgoing packets are queued during hardware address
    resolution. By default, only the most recent packet is queued per IP address.
    This is sufficient for most protocols and mainly reduces TCP connection
    startup time. Set this to 1 if you know your application sends more than one
    packet in a row to an IP address that is not in the ARP cache.
*/
#define ARP_QUEUEING                    1

/*
    --------------------------------
    ---------- IP options ----------
    --------------------------------
*/
/**
    IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that
    this option does not affect outgoing packet sizes, which can be controlled
    via IP_FRAG.
*/
#define IP_REASSEMBLY                   CONFIG_LWIP_IP_REASSEMBLY

/**
    IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note
    that this option does not affect incoming packet sizes, which can be
    controlled via IP_REASSEMBLY.
*/
#define IP_FRAG                         CONFIG_LWIP_IP_FRAG

/**
    IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally)
    a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived
    in this time, the whole packet is discarded.
*/
#define IP_REASS_MAXAGE                 3

/**
    IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled.
    Since the received pbufs are enqueued, be sure to configure
    PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive
    packets even if the maximum amount of fragments is enqueued for reassembly!
*/
#define IP_REASS_MAX_PBUFS              10

/*
    ----------------------------------
    ---------- ICMP options ----------
    ----------------------------------
*/

#define LWIP_BROADCAST_PING CONFIG_LWIP_BROADCAST_PING

#define LWIP_MULTICAST_PING CONFIG_LWIP_MULTICAST_PING

/*
    ---------------------------------
    ---------- RAW options ----------
    ---------------------------------
*/
/**
    LWIP_RAW==1: Enable application layer to hook into the IP layer itself.
*/
#define LWIP_RAW                        1

/*
    ----------------------------------
    ---------- DHCP options ----------
    ----------------------------------
*/
/**
    LWIP_DHCP==1: Enable DHCP module.
*/
#define LWIP_DHCP                       1

#define DHCP_MAXRTX                     0

/**
    DHCP_DOES_ARP_CHECK==1: Do an ARP check on the offered address.
*/
#define DHCP_DOES_ARP_CHECK             CONFIG_LWIP_DHCP_DOES_ARP_CHECK


/**
    CONFIG_LWIP_DHCP_RESTORE_LAST_IP==1: Last valid IP address obtained from DHCP server
    is restored after reset/power-up.
*/
#if CONFIG_LWIP_DHCP_RESTORE_LAST_IP

    #define LWIP_DHCP_IP_ADDR_RESTORE()     dhcp_ip_addr_restore(netif)
    #define LWIP_DHCP_IP_ADDR_STORE()       dhcp_ip_addr_store(netif)
    #define LWIP_DHCP_IP_ADDR_ERASE()       dhcp_ip_addr_erase(esp_netif[tcpip_if])

#endif

/*
    ------------------------------------
    ---------- AUTOIP options ----------
    ------------------------------------
*/
#ifdef CONFIG_LWIP_AUTOIP
    #define LWIP_AUTOIP                     1

    /**
    LWIP_DHCP_AUTOIP_COOP==1: Allow DHCP and AUTOIP to be both enabled on
    the same interface at the same time.
    */
    #define LWIP_DHCP_AUTOIP_COOP           1

    /**
    LWIP_DHCP_AUTOIP_COOP_TRIES: Set to the number of DHCP DISCOVER probes
    that should be sent before falling back on AUTOIP. This can be set
    as low as 1 to get an AutoIP address very quickly, but you should
    be prepared to handle a changing IP address when DHCP overrides
    AutoIP.
    */
    #define LWIP_DHCP_AUTOIP_COOP_TRIES     CONFIG_LWIP_AUTOIP_TRIES

    #define LWIP_AUTOIP_MAX_CONFLICTS CONFIG_LWIP_AUTOIP_MAX_CONFLICTS

    #define LWIP_AUTOIP_RATE_LIMIT_INTERVAL CONFIG_LWIP_AUTOIP_RATE_LIMIT_INTERVAL

#endif /* CONFIG_LWIP_AUTOIP */

/*
    ----------------------------------
    ---------- SNMP options ----------
    ----------------------------------
*/
/*
    ----------------------------------
    ---------- IGMP options ----------
    ----------------------------------
*/
/**
    LWIP_IGMP==1: Turn on IGMP module.
*/
#define LWIP_IGMP                       1

/*
    ----------------------------------
    ---------- DNS options -----------
    ----------------------------------
*/
/**
    LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS
    transport.
*/
#define LWIP_DNS                        1

#define DNS_MAX_SERVERS                 3
#define DNS_FALLBACK_SERVER_INDEX        (DNS_MAX_SERVERS - 1)

/*
    ---------------------------------
    ---------- UDP options ----------
    ---------------------------------
*/
/*
    ---------------------------------
    ---------- TCP options ----------
    ---------------------------------
*/


/**
    TCP_QUEUE_OOSEQ==1: TCP will queue segments that arrive out of order.
    Define to 0 if your device is low on memory.
*/
#define TCP_QUEUE_OOSEQ                 CONFIG_TCP_QUEUE_OOSEQ

/**
    ESP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES==1: Keep TCP connection when IP changed
    scenario happens: 192.168.0.2 -> 0.0.0.0 -> 192.168.0.2 or 192.168.0.2 -> 0.0.0.0
*/

#define ESP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES  CONFIG_ESP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES
/*
       LWIP_EVENT_API==1: The user defines lwip_tcp_event() to receive all
           events (accept, sent, etc) that happen in the system.
       LWIP_CALLBACK_API==1: The PCB callback function is called directly
           for the event. This is the default.
*/
#define TCP_MSS                         CONFIG_TCP_MSS

/**
    TCP_MSL: The maximum segment lifetime in milliseconds
*/
#define TCP_MSL                         CONFIG_TCP_MSL

/**
    TCP_MAXRTX: Maximum number of retransmissions of data segments.
*/
#define TCP_MAXRTX                      CONFIG_TCP_MAXRTX

/**
    TCP_SYNMAXRTX: Maximum number of retransmissions of SYN segments.
*/
#define TCP_SYNMAXRTX                   CONFIG_TCP_SYNMAXRTX

/**
    TCP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb.
*/
#define TCP_LISTEN_BACKLOG              1


/**
    TCP_OVERSIZE: The maximum number of bytes that tcp_write may
    allocate ahead of time
*/
#ifdef CONFIG_TCP_OVERSIZE_MSS
    #define TCP_OVERSIZE                    TCP_MSS
#endif
#ifdef CONFIG_TCP_OVERSIZE_QUARTER_MSS
    #define TCP_OVERSIZE                    (TCP_MSS/4)
#endif
#ifdef CONFIG_TCP_OVERSIZE_DISABLE
    #define TCP_OVERSIZE                    0
#endif
#ifndef TCP_OVERSIZE
    #warning "One of CONFIG_TCP_OVERSIZE_xxx options should be set by sdkconfig"
#endif

/**
    LWIP_WND_SCALE and TCP_RCV_SCALE:
    Set LWIP_WND_SCALE to 1 to enable window scaling.
    Set TCP_RCV_SCALE to the desired scaling factor (shift count in the
    range of [0..14]).
    When LWIP_WND_SCALE is enabled but TCP_RCV_SCALE is 0, we can use a large
    send window while having a small receive window only.
*/
#ifdef CONFIG_LWIP_WND_SCALE
    #define LWIP_WND_SCALE                  1
    #define TCP_RCV_SCALE                   CONFIG_TCP_RCV_SCALE
#endif

/*
    ----------------------------------
    ---------- Pbuf options ----------
    ----------------------------------
*/

/*
    ------------------------------------------------
    ---------- Network Interfaces options ----------
    ------------------------------------------------
*/

/**
    LWIP_NETIF_HOSTNAME==1: use DHCP_OPTION_HOSTNAME with netif's hostname
    field.
*/
#define LWIP_NETIF_HOSTNAME             1

/**
    LWIP_NETIF_TX_SINGLE_PBUF: if this is set to 1, lwIP tries to put all data
    to be sent into one single pbuf. This is for compatibility with DMA-enabled
    MACs that do not support scatter-gather.
    Beware that this might involve CPU-memcpy before transmitting that would not
    be needed without this flag! Use this only if you need to!

    @todo: TCP and IP-frag do not work with this, yet:
*/
#define LWIP_NETIF_TX_SINGLE_PBUF             1

/*
    ------------------------------------
    ---------- LOOPIF options ----------
    ------------------------------------
*/
#ifdef CONFIG_LWIP_NETIF_LOOPBACK
    /**
    LWIP_NETIF_LOOPBACK==1: Support sending packets with a destination IP
    address equal to the netif IP address, looping them back up the stack.
    */
    #define LWIP_NETIF_LOOPBACK             1

    /**
    LWIP_LOOPBACK_MAX_PBUFS: Maximum number of pbufs on queue for loopback
    sending for each netif (0 = disabled)
    */
    #define LWIP_LOOPBACK_MAX_PBUFS         CONFIG_LWIP_LOOPBACK_MAX_PBUFS
#endif

/*
    ------------------------------------
    ---------- SLIPIF options ----------
    ------------------------------------
*/

/*
    ------------------------------------
    ---------- Thread options ----------
    ------------------------------------
*/
/**
    TCPIP_THREAD_NAME: The name assigned to the main tcpip thread.
*/
#define TCPIP_THREAD_NAME              "tiT"

/**
    TCPIP_THREAD_STACKSIZE: The stack size used by the main tcpip thread.
    The stack size value itself is platform-dependent, but is passed to
    sys_thread_new() when the thread is created.
*/
#define TCPIP_THREAD_STACKSIZE          ESP_TASK_TCPIP_STACK

/**
    TCPIP_THREAD_PRIO: The priority assigned to the main tcpip thread.
    The priority value itself is platform-dependent, but is passed to
    sys_thread_new() when the thread is created.
*/
#define TCPIP_THREAD_PRIO               ESP_TASK_TCPIP_PRIO

/**
    TCPIP_MBOX_SIZE: The mailbox size for the tcpip thread messages
    The queue size value itself is platform-dependent, but is passed to
    sys_mbox_new() when tcpip_init is called.
*/
#define TCPIP_MBOX_SIZE                 CONFIG_TCPIP_RECVMBOX_SIZE

/**
    DEFAULT_UDP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a
    NETCONN_UDP. The queue size value itself is platform-dependent, but is passed
    to sys_mbox_new() when the recvmbox is created.
*/
#define DEFAULT_UDP_RECVMBOX_SIZE       CONFIG_UDP_RECVMBOX_SIZE

/**
    DEFAULT_TCP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a
    NETCONN_TCP. The queue size value itself is platform-dependent, but is passed
    to sys_mbox_new() when the recvmbox is created.
*/
#define DEFAULT_TCP_RECVMBOX_SIZE       CONFIG_TCP_RECVMBOX_SIZE

/**
    DEFAULT_ACCEPTMBOX_SIZE: The mailbox size for the incoming connections.
    The queue size value itself is platform-dependent, but is passed to
    sys_mbox_new() when the acceptmbox is created.
*/
#define DEFAULT_ACCEPTMBOX_SIZE         6

/**
    DEFAULT_THREAD_STACKSIZE: The stack size used by any other lwIP thread.
    The stack size value itself is platform-dependent, but is passed to
    sys_thread_new() when the thread is created.
*/
#define DEFAULT_THREAD_STACKSIZE        TCPIP_THREAD_STACKSIZE

/**
    DEFAULT_THREAD_PRIO: The priority assigned to any other lwIP thread.
    The priority value itself is platform-dependent, but is passed to
    sys_thread_new() when the thread is created.
*/
#define DEFAULT_THREAD_PRIO             TCPIP_THREAD_PRIO

/**
    DEFAULT_RAW_RECVMBOX_SIZE: The mailbox size for the incoming packets on a
    NETCONN_RAW. The queue size value itself is platform-dependent, but is passed
    to sys_mbox_new() when the recvmbox is created.
*/
#define DEFAULT_RAW_RECVMBOX_SIZE       6

/*
    ----------------------------------------------
    ---------- Sequential layer options ----------
    ----------------------------------------------
*/
/**
    LWIP_TCPIP_CORE_LOCKING: (EXPERIMENTAL!)
    Don't use it if you're not an active lwIP project member
*/
#define LWIP_TCPIP_CORE_LOCKING         0

/*
    ------------------------------------
    ---------- Socket options ----------
    ------------------------------------
*/
/**
    LWIP_SO_SNDTIMEO==1: Enable send timeout for sockets/netconns and
    SO_SNDTIMEO processing.
*/
#define LWIP_SO_SNDTIMEO                1

/**
    LWIP_SO_RCVTIMEO==1: Enable receive timeout for sockets/netconns and
    SO_RCVTIMEO processing.
*/
#define LWIP_SO_RCVTIMEO                1

/**
    LWIP_TCP_KEEPALIVE==1: Enable TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT
    options processing. Note that TCP_KEEPIDLE and TCP_KEEPINTVL have to be set
    in seconds. (does not require sockets.c, and will affect tcp.c)
*/
#define LWIP_TCP_KEEPALIVE              1

/**
    LWIP_SO_RCVBUF==1: Enable SO_RCVBUF processing.
*/
#define LWIP_SO_RCVBUF                  CONFIG_LWIP_SO_RCVBUF

/**
    SO_REUSE==1: Enable SO_REUSEADDR option.
    This option is set via menuconfig.
*/
#define SO_REUSE                        CONFIG_LWIP_SO_REUSE

/**
    SO_REUSE_RXTOALL==1: Pass a copy of incoming broadcast/multicast packets
    to all local matches if SO_REUSEADDR is turned on.
    WARNING: Adds a memcpy for every packet if passing to more than one pcb!
*/
#define SO_REUSE_RXTOALL                CONFIG_LWIP_SO_REUSE_RXTOALL

/*
    ----------------------------------------
    ---------- Statistics options ----------
    ----------------------------------------
*/

/**
    LWIP_STATS==1: Enable statistics collection in lwip_stats.
*/
#define LWIP_STATS                      CONFIG_LWIP_STATS

#if LWIP_STATS

    /**
    LWIP_STATS_DISPLAY==1: Compile in the statistics output functions.
    */
    #define LWIP_STATS_DISPLAY              CONFIG_LWIP_STATS
#endif


/*
    ---------------------------------
    ---------- PPP options ----------
    ---------------------------------
*/

/**
    PPP_SUPPORT==1: Enable PPP.
*/
#define PPP_SUPPORT                     CONFIG_PPP_SUPPORT

#if PPP_SUPPORT

    /**
    PAP_SUPPORT==1: Support PAP.
    */
    #define PAP_SUPPORT                     CONFIG_PPP_PAP_SUPPORT

    /**
    CHAP_SUPPORT==1: Support CHAP.
    */
    #define CHAP_SUPPORT                    CONFIG_PPP_CHAP_SUPPORT

    /**
    MSCHAP_SUPPORT==1: Support MSCHAP.
    */
    #define MSCHAP_SUPPORT                  CONFIG_PPP_MSCHAP_SUPPORT

    /**
    CCP_SUPPORT==1: Support CCP.
    */
    #define MPPE_SUPPORT                    CONFIG_PPP_MPPE_SUPPORT

    /**
    PPP_MAXIDLEFLAG: Max Xmit idle time (in ms) before resend flag char.
    TODO: If PPP_MAXIDLEFLAG > 0 and next package is send during PPP_MAXIDLEFLAG time,
    then 0x7E is not added at the begining of PPP package but 0x7E termination
    is always at the end. This behaviour brokes PPP dial with GSM (PPPoS).
    The PPP package should always start and end with 0x7E.
    */

    #define PPP_MAXIDLEFLAG                 0

    /**
    PPP_DEBUG: Enable debugging for PPP.
    */
    #define PPP_DEBUG_ON					CONFIG_PPP_DEBUG_ON

    #if PPP_DEBUG_ON
        #define PPP_DEBUG                       LWIP_DBG_ON
    #else
        #define PPP_DEBUG                       LWIP_DBG_OFF
    #endif

#endif

/*
    --------------------------------------
    ---------- Checksum options ----------
    --------------------------------------
*/

/*
    ---------------------------------------
    ---------- IPv6 options ---------------
    ---------------------------------------
*/
/**
    LWIP_IPV6==1: Enable IPv6
*/
#define LWIP_IPV6                       1

/*
    ---------------------------------------
    ---------- Hook options ---------------
    ---------------------------------------
*/
#define LWIP_HOOK_IP4_ROUTE_SRC         ip4_route_src_hook
/*
    ---------------------------------------
    ---------- Debugging options ----------
    ---------------------------------------
*/
/**
    ETHARP_DEBUG: Enable debugging in etharp.c.
*/
#define ETHARP_DEBUG                    LWIP_DBG_OFF

/**
    NETIF_DEBUG: Enable debugging in netif.c.
*/
#define NETIF_DEBUG                     LWIP_DBG_OFF

/**
    PBUF_DEBUG: Enable debugging in pbuf.c.
*/
#define PBUF_DEBUG                      LWIP_DBG_OFF

/**
    API_LIB_DEBUG: Enable debugging in api_lib.c.
*/
#define API_LIB_DEBUG                   LWIP_DBG_OFF

/**
    SOCKETS_DEBUG: Enable debugging in sockets.c.
*/
#define SOCKETS_DEBUG                   LWIP_DBG_OFF

/**
    ICMP_DEBUG: Enable debugging in icmp.c.
*/
#define ICMP_DEBUG                      LWIP_DBG_OFF

/**
    IP_DEBUG: Enable debugging for IP.
*/
#define IP_DEBUG                        LWIP_DBG_OFF

/**
    MEMP_DEBUG: Enable debugging in memp.c.
*/
#define MEMP_DEBUG                      LWIP_DBG_OFF

/**
    TCP_INPUT_DEBUG: Enable debugging in tcp_in.c for incoming debug.
*/
#define TCP_INPUT_DEBUG                 LWIP_DBG_OFF

/**
    TCP_OUTPUT_DEBUG: Enable debugging in tcp_out.c output functions.
*/
#define TCP_OUTPUT_DEBUG                LWIP_DBG_OFF

/**
    TCPIP_DEBUG: Enable debugging in tcpip.c.
*/
#define TCPIP_DEBUG                     LWIP_DBG_OFF

/**
    ETHARP_TRUST_IP_MAC==1: Incoming IP packets cause the ARP table to be
    updated with the source MAC and IP addresses supplied in the packet.
    You may want to disable this if you do not trust LAN peers to have the
    correct addresses, or as a limited approach to attempt to handle
    spoofing. If disabled, lwIP will need to make a new ARP request if
    the peer is not already in the ARP table, adding a little latency.
    The peer *is* in the ARP table if it requested our address before.
    Also notice that this slows down input processing of every IP packet!
*/
#define ETHARP_TRUST_IP_MAC             CONFIG_LWIP_ETHARP_TRUST_IP_MAC


/**
    POSIX I/O functions are mapped to LWIP via the VFS layer
    (see port/vfs_lwip.c)
*/
#define LWIP_POSIX_SOCKETS_IO_NAMES     0

/**
    FD_SETSIZE from sys/types.h is the maximum number of supported file
    descriptors and CONFIG_LWIP_MAX_SOCKETS defines the number of sockets;
    LWIP_SOCKET_OFFSET is configured to use the largest numbers of file
    descriptors for sockets. File descriptors from 0 to LWIP_SOCKET_OFFSET-1
    are non-socket descriptors and from LWIP_SOCKET_OFFSET to FD_SETSIZE are
    socket descriptors.
*/
#define LWIP_SOCKET_OFFSET              (FD_SETSIZE - CONFIG_LWIP_MAX_SOCKETS)

/* Enable all Espressif-only options */

#define ESP_LWIP                        1
#define ESP_LWIP_ARP                    1
#define ESP_PER_SOC_TCP_WND             0
#define ESP_THREAD_SAFE                 1
#define ESP_THREAD_SAFE_DEBUG           LWIP_DBG_OFF
#define ESP_DHCP                        1
#define ESP_DNS                         1
#define ESP_IPV6_AUTOCONFIG             1
#define ESP_PERF                        0
#define ESP_RANDOM_TCP_PORT             1
#define ESP_IP4_ATON                    1
#define ESP_LIGHT_SLEEP                 1
#define ESP_L2_TO_L3_COPY               CONFIG_L2_TO_L3_COPY
#define ESP_STATS_MEM                   CONFIG_LWIP_STATS
#define ESP_STATS_DROP                  CONFIG_LWIP_STATS
#define ESP_STATS_TCP                   0
#define ESP_DHCP_TIMER                  1
#define ESP_DHCPS_TIMER                 1
#define ESP_LWIP_LOGI(...)              ESP_LOGI("lwip", __VA_ARGS__)
#define ESP_PING                        1
#define ESP_HAS_SELECT                  1
#define ESP_AUTO_RECV                   1
#define ESP_GRATUITOUS_ARP              CONFIG_ESP_GRATUITOUS_ARP

#if CONFIG_LWIP_IRAM_OPTIMIZATION
    #define ESP_IRAM_ATTR                   IRAM_ATTR
#else
    #define ESP_IRAM_ATTR
#endif

#if ESP_PERF
#define DBG_PERF_PATH_SET(dir, point)
#define DBG_PERF_FILTER_LEN             1000

enum {
    DBG_PERF_DIR_RX = 0,
    DBG_PERF_DIR_TX,
};

enum {
    DBG_PERF_POINT_INT       = 0,
    DBG_PERF_POINT_WIFI_IN   = 1,
    DBG_PERF_POINT_WIFI_OUT  = 2,
    DBG_PERF_POINT_LWIP_IN   = 3,
    DBG_PERF_POINT_LWIP_OUT  = 4,
    DBG_PERF_POINT_SOC_IN    = 5,
    DBG_PERF_POINT_SOC_OUT   = 6,
};

#else
#define DBG_PERF_PATH_SET(dir, point)
#define DBG_PERF_FILTER_LEN             1000
#endif

#define TCP_SND_BUF                     CONFIG_TCP_SND_BUF_DEFAULT
#define TCP_WND                         CONFIG_TCP_WND_DEFAULT

#if ESP_PER_SOC_TCP_WND
    #define TCP_WND_DEFAULT                 CONFIG_TCP_WND_DEFAULT
    #define TCP_SND_BUF_DEFAULT             CONFIG_TCP_SND_BUF_DEFAULT
    #define TCP_WND(pcb)                    (pcb->per_soc_tcp_wnd)
    #define TCP_SND_BUF(pcb)                (pcb->per_soc_tcp_snd_buf)
    #define TCP_SND_QUEUELEN(pcb)           ((4 * (TCP_SND_BUF((pcb))) + (TCP_MSS - 1))/(TCP_MSS))
    #define TCP_SNDLOWAT(pcb)               LWIP_MIN(LWIP_MAX(((TCP_SND_BUF((pcb)))/2), (2 * TCP_MSS) + 1), (TCP_SND_BUF((pcb))) - 1)
    #define TCP_SNDQUEUELOWAT(pcb)          LWIP_MAX(((TCP_SND_QUEUELEN((pcb)))/2), 5)
    #define TCP_WND_UPDATE_THRESHOLD(pcb)   LWIP_MIN((TCP_WND((pcb)) / 4), (TCP_MSS * 4))
#endif

/**
    DHCP_DEBUG: Enable debugging in dhcp.c.
*/
#define DHCP_DEBUG                      LWIP_DBG_OFF
#define LWIP_DEBUG                      LWIP_DBG_OFF
#define TCP_DEBUG                       LWIP_DBG_OFF

#define CHECKSUM_CHECK_UDP              0
#define CHECKSUM_CHECK_IP               0

#define LWIP_NETCONN_FULLDUPLEX         1
#define LWIP_NETCONN_SEM_PER_THREAD     1

#define LWIP_DHCP_MAX_NTP_SERVERS       CONFIG_LWIP_DHCP_MAX_NTP_SERVERS
#define LWIP_TIMEVAL_PRIVATE            0

#define SNTP_SET_SYSTEM_TIME_US(sec, us)  \
    do { \
        struct timeval tv = { .tv_sec = sec, .tv_usec = us }; \
        settimeofday(&tv, NULL); \
    } while (0);

#define SNTP_GET_SYSTEM_TIME(sec, us) \
    do { \
        struct timeval tv = { .tv_sec = 0, .tv_usec = 0 }; \
        gettimeofday(&tv, NULL); \
        (sec) = tv.tv_sec;  \
        (us) = tv.tv_usec; \
    } while (0);

#define SOC_SEND_LOG //printf

#endif /* __LWIPOPTS_H__ */
